package com.zhongchaowuye.controller;

import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.tools.Tool;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.github.pagehelper.Page;
import com.zhongchaowuye.pojo.B_GZ;
import com.zhongchaowuye.pojo.B_HT;
import com.zhongchaowuye.pojo.B_HT_M;
import com.zhongchaowuye.pojo.B_TZh;
import com.zhongchaowuye.service.B_GZService;
import com.zhongchaowuye.service.B_HTService;
import com.zhongchaowuye.service.B_HT_MService;
import com.zhongchaowuye.service.B_TZhService;
import com.zhongchaowuye.utils.Tools;

@Controller
@RequestMapping("/b_HT_M")
public class B_HT_MController {

	@Resource
	private B_HT_MService b_HT_MService;
	@Resource
	private B_HTService b_HTService;
	@Resource
	private B_GZService b_GZService;
	@Resource
	private B_TZhService b_TZhService;
	
	@RequestMapping(value ="/getB_HT_M",method = RequestMethod.POST)
	@ResponseBody
	//根据id获取B_HT_M对象信息
	public Map<String,Object> getB_HT_M(HttpServletRequest request,B_HT_M ht_m){
		Map<String,Object> reMap=new HashMap<>();
		try {
			B_HT_M b_HT_M=b_HT_MService.getB_HT_M(ht_m);
			reMap.put("b_HT_M", b_HT_M);
			reMap.put("status", "success");
			reMap.put("message", "OK");
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			reMap.put("status", "error");
			reMap.put("message", e.getMessage());
		}
		return reMap;
	}

	@RequestMapping(value ="/getB_HT_MList",method = RequestMethod.POST)
	@ResponseBody
	//获取列表
	public Map<String,Object> getB_HT_MList(HttpServletRequest request,B_HT_M b_HT_M){
		Map<String,Object> reMap=new HashMap<>();//定义返回值，其中有一项必须是集合，先按照下面的写法
		try {
			//List<Map<String,Object>> rList=b_HT_MService.getB_HT_MList(b_HT_M); //不带分页（注意实现类中的相应写法）
			Page<Map<String,Object>> rList = (Page)b_HT_MService.getB_HT_MList(b_HT_M);
			
			//System.out.println(rList);
			reMap.put("rows", rList);
			reMap.put("total", rList.getTotal());
			reMap.put("pageIndex", b_HT_M.getPageIndex());
			reMap.put("pageSize", b_HT_M.getPageSize());
			reMap.put("status", "success");
			reMap.put("message", "OK");
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			reMap.put("status", "error");
			reMap.put("message", e.getMessage());
		}
		return reMap;
	}

	@RequestMapping(value ="/insertB_HT_M",method = RequestMethod.POST)
	@ResponseBody
	//添加
	public Map<String,Object> insertB_HT_M(HttpServletRequest request,B_HT_M b_HT_M)   
	{
		Map<String,Object> reMap=new HashMap<>();//返回值map
		try 
		{
			//补齐创建者与创建时间
			//b_HT_M.setCrea("");
			//Timestamp cur=new Timestamp(System.currentTimeMillis()); 
			//b_HT_M.setCrea_time(cur); //或者直接在sql语句中使用now()函数填充对应的值
			int flag=b_HT_MService.insertB_HT_M(b_HT_M);
			//int flag = 0;
			if(flag>0)
			{
				reMap.put("status", "success");
				reMap.put("message", "OK");
			}
			else
			{
				reMap.put("status", "error");
				reMap.put("message", "ERROR");
			}
			
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			reMap.put("status", "error");
			reMap.put("message", e.getMessage());
		}
		return reMap;
	}
	
	@RequestMapping(value ="/updateB_HT_M",method = RequestMethod.POST)
	@ResponseBody
	//修改
	public Map<String,Object> updateB_HT_M(HttpServletRequest request,B_HT_M b_HT_M)   
	{
		Map<String,Object> reMap=new HashMap<>();//返回值map
		try 
		{
			int flag=b_HT_MService.updateB_HT_M(b_HT_M);
			if(flag>0)
			{
				reMap.put("status", "success");
				reMap.put("message", "OK");
			}
			else
			{
				reMap.put("status", "error");
				reMap.put("message", "ERROR");
			}
			
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			reMap.put("status", "error");
			reMap.put("message", e.getMessage());
		}
		return reMap;
	}
	
	@RequestMapping(value ="/delB_HT_M",method = RequestMethod.POST)
	@ResponseBody
	//软删除
	public Map<String,Object> delB_HT_M(HttpServletRequest request,B_HT_M b_HT_M)   
	{
		Map<String,Object> reMap=new HashMap<>();//返回值map
		Map<String,Object> m=new HashMap<>();
		try 
		{
			int flag=b_HT_MService.delB_HT_M(b_HT_M);
			if(flag>0)
			{
				reMap.put("status", "success");
				reMap.put("message", "OK");
			}
			else
			{
				reMap.put("status", "error");
				reMap.put("message", "ERROR");
			}
			
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			reMap.put("status", "error");
			reMap.put("message", e.getMessage());
		}
		return reMap;
	}
	
	@RequestMapping(value ="/jisuan_xiangmu",method = RequestMethod.POST)
	@ResponseBody
	//根据项目（合同）名称、年月、当月工作日天数进行项目相关数据的获取与计算
	public Map<String,Object> jisuan_xiangmu(HttpServletRequest request,B_HT b_HT,BigDecimal m_gongzuori){
		Map<String,Object> reMap=new HashMap<>();//定义返回值，其中有一项必须是集合，先按照下面的写法
		try {
			//1：有效参数是 “项目名称”与 “年月”，根据 项目名称=合同名称 and 年月>=合同开始时间 and 年月<=合同结束时间
			//   找到对应的合同数据，当涉及到非整月跨月合同时，查询的结果是老合同
			Page<Map<String,Object>> rList = (Page)b_HTService.getB_HTList(b_HT);
			System.out.println("项目基本信息查询结果=="+rList);
			
			//用于辅助计算的项目月数据所在的年月（定义在Base基类中）
			String m_time=b_HT.getM_time(); //格式为yyyy-MM-01 00:00:00
			String m_time_MM=m_time.substring(0,7); //得到yyyy-MM格式的年月
			
			//定义变量，用于接收结果集中的数据
			String ht_end=""; //合同截止日期,格式为yyyy-MM-dd 23:59:59
			
			//取税率
			double ht_shuilv=0;
			
			//月合同额计算单元 
			double ht_zongjinE=0; //合同总金额
			int ht_yueshu=0; //合同跨越月数
			//餐费计算单元
			int ht_renshu_yongcan=0; //合同用餐人数
			double ht_canbiao=0; //合同餐标
			double m_gzr=m_gongzuori.doubleValue(); //（非整月情况）
			//物业费计算单元（纯计算）
			//物业费 = 月合同额 - 月餐费
			
			if(rList.size()==0){
				//再用setM_time(月末日期235959进行查询)
				B_HT xht=new B_HT(); //构造查询条件（xht代表新合同）
				xht.setHt_xiangmu_name(b_HT.getHt_xiangmu_name()); //条件一：项目名称
				String ldm=Tools.lastDayOfMonth(b_HT.getM_time().substring(0,10));
				xht.setM_time(ldm); //条件二：年月（用当前年月的最后一天，这个返回值是带时分秒的）
				xht.setPageIndex(Integer.valueOf(1));
				xht.setPageSize(Integer.valueOf(1000));
				Page<Map<String,Object>> rs = (Page)b_HTService.getB_HTList(xht);
				if(rs.size()==0){
					//提示无结果
					reMap.put("status", "error");
					reMap.put("message", "没有对应的合同数据");
					return reMap; //直接返回
				}else{
					//说明有新签的合同，并处于开始的首月半月
					int i=0;
					for(Map m:rs){ //1条合同记录
						if(i==1){
							break;
						}
						System.out.println("取到新签合同有用的键值对数据=="+m);
						
						//取得新签合同的相关数据
						//取税率（转为double类型）
						double ht_shuilv_new=((BigDecimal)m.get("ht_shuilv")).doubleValue();
						
						//月合同额计算单元
						//取合同额数据（转为double类型）
						double ht_zongjinE_new=((BigDecimal)m.get("ht_zongjinE")).doubleValue();
						//取合同所跨月数（转为int类型）
						int ht_yueshu_new=((Integer)m.get("ht_yueshu")).intValue();
						
						//餐费计算单元
						//取合同用餐人数（转为int类型）
						int ht_renshu_yongcan_new=((Integer)m.get("ht_renshu_yongcan")).intValue();
						//取合同餐标（转为double类型）
						double ht_canbiao_new=((BigDecimal)m.get("ht_canbiao")).doubleValue();
						
						//计算比例
						String ht_end_new=Tools.TimestampToString((Timestamp)m.get("ht_end"));
						String ht_end_dd=ht_end_new.substring(8,10); //先获取合同的开始日（dd项）
						String ht_end_daysNum=Tools.daysInMonth(ht_end_new.substring(0,4), ht_end_new.substring(5,7));
						int daysInMonth_L=Integer.valueOf(ht_end_dd); //合同结束日的数字
						int daysInMonth=Integer.valueOf(ht_end_daysNum); //当前月的天数
						double bili_L=Tools.getBili(daysInMonth_L,daysInMonth,8); //获得保留8位小数的比例
						
						xiangmu_kuaMM(0,12,0,0,0,
								      ht_zongjinE_new,ht_yueshu_new,ht_canbiao_new,ht_renshu_yongcan_new,ht_shuilv_new,
								      m_gzr,bili_L,reMap);
						i++;
					} //for循环结束
				}
			}else{ //如果初始查询有结果
				//执行下面的已写好的逻辑（从int i=0;到主逻辑已结束行）
				int i=0;
				for(Map m:rList){ //1条合同记录
					if(i==1){
						break;
					}
					System.out.println("循环中取到的有用的键值对数据=="+m);
					//取合同结束日期（转为字符串类型）格式为yyyy-MM-dd 23:59:59
					ht_end=Tools.TimestampToString((Timestamp)m.get("ht_end")); 
					
					//取税率（转为double类型）
					ht_shuilv=((BigDecimal)m.get("ht_shuilv")).doubleValue();
					
					//月合同额计算单元
					//取合同额数据（转为double类型）
					ht_zongjinE=((BigDecimal)m.get("ht_zongjinE")).doubleValue();
					//取合同所跨月数（转为int类型）
					ht_yueshu=((Integer)m.get("ht_yueshu")).intValue();
					
					//餐费计算单元
					//取合同用餐人数（转为int类型）
					ht_renshu_yongcan=((Integer)m.get("ht_renshu_yongcan")).intValue();
					//取合同餐标（转为double类型）
					ht_canbiao=((BigDecimal)m.get("ht_canbiao")).doubleValue();
					
					i++;
				}
				String ht_end_MM=ht_end.substring(0,7); //取合同结束日期的年月（格式为：yyyy-MM）
				
				//2：判断当前年月是否为合同期的最后一个月
				if(m_time_MM.equals(ht_end_MM)){ //⑵如果是
					System.out.println("当前年月是合同期的最后一个月！！！");
					//判断ht_end是否是整月结束的
					String ht_end_dd=ht_end.substring(8,10); //先获取合同的结束日（dd项）
					String ht_end_daysNum=Tools.daysInMonth(ht_end.substring(0,4), ht_end.substring(5,7)); //再计算合同结束日所在月的天数
					if(ht_end_dd.equals(ht_end_daysNum)){ //A：如果合同期是整月结束的，则走⑴的逻辑
						System.out.println("是整月结束的合同");
						xiangmu_zhengMM(ht_zongjinE,ht_yueshu,ht_canbiao,ht_renshu_yongcan,m_gzr,ht_shuilv,reMap);
					}else{ //B：如果合同不是整月结束的
						System.out.println("存在跨月的合同，这里需要算比例");
						
						//计算非整月合同的结束日占结束月份的比例
						int daysInMonth_L=Integer.valueOf(ht_end_dd); //合同结束日的数字
						int daysInMonth=Integer.valueOf(ht_end_daysNum); //当前月的天数
						double bili_L=Tools.getBili(daysInMonth_L,daysInMonth,8); //获得保留8位小数的比例
						double bili_R=1-bili_L; //新合同在开始月所占天数的比例
						
						//需要取新合同的数据
						B_HT xht=new B_HT(); //构造查询条件
						xht.setHt_xiangmu_name(b_HT.getHt_xiangmu_name()); //条件一：项目名称
						String nmfd=Tools.nextMonthFirstDay(b_HT.getM_time().substring(0,10));
						xht.setM_time(nmfd); //条件二：年月（用当前年月的下一个月的1日，这个返回值是带时分秒的）
						xht.setPageIndex(Integer.valueOf(1));
						xht.setPageSize(Integer.valueOf(1000));
						Page<Map<String,Object>> rs = (Page)b_HTService.getB_HTList(xht);
						System.out.println("项目（非整月新合同）基本信息查询结果=="+rs);
						
						if(rs.size()==0){ //取新合同并没有取到
							//说明没有续签，原合同结束
							//使用原合同的参数以及左侧比例进行计算
							xiangmu_kuaMM(ht_zongjinE,ht_yueshu,ht_canbiao,ht_renshu_yongcan,ht_shuilv,
							              0,12,0,0,0,
							              m_gzr,bili_L,reMap);
						}else{ 
							//说明合同有续签，
							int j=0;
							for(Map m:rs){ //1条合同记录
								if(j==1){
									break;
								}
								System.out.println("new循环中取到的有用的键值对数据=="+m);
								
								//取得新合同的相关数据
								//取税率（转为double类型）
								double ht_shuilv_new=((BigDecimal)m.get("ht_shuilv")).doubleValue();
								//月合同额计算单元
								//取合同额数据（转为double类型）
								double ht_zongjinE_new=((BigDecimal)m.get("ht_zongjinE")).doubleValue();
								//取合同所跨月数（转为int类型）
								int ht_yueshu_new=((Integer)m.get("ht_yueshu")).intValue();
								
								//餐费计算单元
								//取合同用餐人数（转为int类型）
								int ht_renshu_yongcan_new=((Integer)m.get("ht_renshu_yongcan")).intValue();
								//取合同餐标（转为double类型）
								double ht_canbiao_new=((BigDecimal)m.get("ht_canbiao")).doubleValue();
								xiangmu_kuaMM(ht_zongjinE,ht_yueshu,ht_canbiao,ht_renshu_yongcan,ht_shuilv,
										      ht_zongjinE_new,ht_yueshu_new,ht_canbiao_new,ht_renshu_yongcan_new,ht_shuilv_new,
										      m_gzr,bili_L,reMap);
								j++;
							} //for循环结束
						} //else结束
					} //else结束（B：如果合同不是整月结束的）
				}else{ //⑴如果不是（通常的正常情况）（判断当前年月是否为合同期的最后一个月）
					xiangmu_zhengMM(ht_zongjinE,ht_yueshu,ht_canbiao,ht_renshu_yongcan,m_gzr,ht_shuilv,reMap);
				}
			}
			
			
			//主逻辑到此结束
			
			reMap.put("status", "success");
			reMap.put("message", "OK");
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			reMap.put("status", "error");
			reMap.put("message", e.getMessage());
		}
		return reMap;
	}
	//处理整月合同（并在结果集中保存月均摊合同额、月餐费、月物业费）
	public void xiangmu_zhengMM(double ht_zongjinE,   //合同总金额
			                    int ht_yueshu,        //合同跨越月数
			                    double ht_canbiao,    //合同餐标
			                    int ht_renshu_yongcan,//合同用餐人数 
			                    double m_gzr,         //当月的工作日天数
			                    double ht_shuilv,     //税率
			                    Map<String,Object> reMap){
		
		double m_hetongfei=0; //月均摊合同额（整月正常情况）
		double m_shuifei=0;   //税费（整月正常情况）
		double m_canfei=0;    //月餐费（整月正常情况）
		double m_wuyefei=0;   //月物业费（整月正常情况）
		//月合同额=合同额/跨月份数
		m_hetongfei=ht_zongjinE/ht_yueshu;
		//税费=月合同额*税率
		m_shuifei=m_hetongfei*ht_shuilv;
		//餐费=餐标*合同用餐人数*当月工作日
		m_canfei=ht_canbiao*ht_renshu_yongcan*m_gzr;
		//物业费=月合同额-餐费
		m_wuyefei=m_hetongfei-m_canfei;
		
		reMap.put("m_hetongfei",m_hetongfei); //结果集保存月均摊合同额
		reMap.put("m_shuifei",m_shuifei); //结果集保存税费
		reMap.put("m_canfei",m_canfei); //结果集保存月餐费
		reMap.put("m_wuyefei",m_wuyefei); //结果集保存月物业费
	}
	//处理非整月合同（并在结果集中保存月均摊合同额、月餐费、月物业费）
	public void xiangmu_kuaMM(double ht_zongjinE,   //上期合同总金额
					          int ht_yueshu,        //上期合同跨越月数
					          double ht_canbiao,    //上期合同餐标
					          int ht_renshu_yongcan,//上期合同用餐人数 
					          double ht_shuilv,     //上期合同税率
					          
					          double ht_zongjinE_new,   //新合同总金额
			                  int ht_yueshu_new,        //新合同跨越月数
			                  double ht_canbiao_new,    //新合同餐标
			                  int ht_renshu_yongcan_new,//新合同用餐人数 
			                  double ht_shuilv_new,     //新合同税率
					          
					          double m_gzr,         //当月的工作日天数
					          double bili_L,        //上期合同结束日所占当月天数的比例
			                  Map<String, Object> reMap){
		
		
		double m_hetongfei=0; //月均摊合同额（非整月跨月情况）
		double m_shuifei=0;   //税费（非整月跨月情况）
		double m_canfei=0;    //月餐费（非整月跨月情况）
		double m_wuyefei=0;   //月物业费（非整月跨月情况）
		//月合同额=上期合同额/上期跨月份数*上期比例 + 新合同额/新跨月份数*新比例
		m_hetongfei=((ht_zongjinE/ht_yueshu)*bili_L)+((ht_zongjinE_new/ht_yueshu_new)*(1-bili_L));
		//税费=(上期合同额/上期跨月份数*上期比例)*上期合同税率 + (新合同额/新跨月份数*新比例)*新合同税率
		m_shuifei=((ht_zongjinE/ht_yueshu)*bili_L)*ht_shuilv+((ht_zongjinE_new/ht_yueshu_new)*(1-bili_L))*ht_shuilv_new;
		//餐费=上期餐标*上期合同用餐人数*当月工作日*上期比例 + 新餐标*新合同用餐人数*当月工作日*新比例
		m_canfei=ht_canbiao*ht_renshu_yongcan*m_gzr*bili_L+ht_canbiao_new*ht_renshu_yongcan_new*m_gzr*(1-bili_L);
		//物业费=月合同额-餐费
		m_wuyefei=m_hetongfei-m_canfei;
		
		reMap.put("m_hetongfei",m_hetongfei); //结果集保存月均摊合同额
		reMap.put("m_shuifei",m_shuifei); //结果集保存税费
		reMap.put("m_canfei",m_canfei); //结果集保存月餐费
		reMap.put("m_wuyefei",m_wuyefei); //结果集保存月物业费
	}
	
	@RequestMapping(value ="/jisuan_gongzi",method = RequestMethod.POST)
	@ResponseBody
	//根据项目（合同）名称、年月获取薪资统计数据
	public Map<String,Object> jisuan_gongzi(HttpServletRequest request,B_GZ b_GZ){
		Map<String,Object> reMap=new HashMap<>();//定义返回值，其中有一项必须是集合，先按照下面的写法
		
		try {
			List<Map<String,Object>> rList=b_GZService.getTjxx(b_GZ); 
			//System.out.println(rList);//这种list方式的查询如果没有结果的话，会是[null]的方式返回
			if(rList.contains(null)){
				reMap.put("rows", null);
			}else{
				reMap.put("rows", rList);
			}
			reMap.put("status", "success");
			reMap.put("message", "OK");
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			reMap.put("status", "error");
			reMap.put("message", e.getMessage());
		}
		return reMap;
	}
	
	@RequestMapping(value ="/jisuan_taizhang",method = RequestMethod.POST)
	@ResponseBody
	//根据项目（合同）名称、日期获取台账统计数据
	public Map<String,Object> jisuan_taizhang(HttpServletRequest request,B_TZh b_TZh){
		Map<String,Object> reMap=new HashMap<>();//定义返回值，其中有一项必须是集合，先按照下面的写法
		
		try {
			//需要根据m_time构建当前月第一天与最后一天，并赋值给start_time与end_time
			//需要给tjxx_type_name属性赋值 “耗材” “物业支出” “食材”
			//分3次调用接口获取这3个统计数据
			//取 “耗材” 数据
			B_TZh q_haocai=new B_TZh(); //构造台账查询条件
			q_haocai.setTjxx_type_name("耗材");
			q_haocai.setTz_xiangmu_name(b_TZh.getTz_xiangmu_name());
			String start_time=b_TZh.getM_time().substring(0,7)+"-01 00:00:00"; //构造当月1日
		    String end_time=Tools.lastDayOfMonth(start_time.substring(0,10)); 
		    q_haocai.setStart_time(start_time);
		    q_haocai.setEnd_time(end_time);
			List<Map<String,Object>> rList1=b_TZhService.getTjxx(q_haocai); //取耗材 
			int i=0;
			if(rList1.contains(null)){
				reMap.put("m_haocai", 0);
			}else{
				for(Map m:rList1){ //1条统计记录
					if(i==1){
						break;
					}
					System.out.println("取耗材统计数据=="+m);
					//double total_tz_heji=m.get("total_tz_heji")==null ? 0 : ((BigDecimal)m.get("total_tz_heji")).doubleValue();
					double total_tz_heji=((BigDecimal)m.get("total_tz_heji")).doubleValue();
					reMap.put("m_haocai", total_tz_heji);
					i++;
				} //for循环结束
			}
			
			
			//取 “物业支出” 数据
			B_TZh q_wuyezhichu=new B_TZh(); //构造台账查询条件
			q_wuyezhichu.setTjxx_type_name("物业支出");
			q_wuyezhichu.setTz_xiangmu_name(b_TZh.getTz_xiangmu_name());
			q_wuyezhichu.setStart_time(start_time);
			q_wuyezhichu.setEnd_time(end_time);
			List<Map<String,Object>> rList2=b_TZhService.getTjxx(q_wuyezhichu); //取物业支出
			if(rList2.contains(null)){
				reMap.put("m_wuyezhichu", 0);
			}else{
				i=0;
				for(Map m:rList2){ //1条统计记录
					if(i==1){
						break;
					}
					System.out.println("取物业支出统计数据=="+m);
					double total_tz_heji=((BigDecimal)m.get("total_tz_heji")).doubleValue();
					reMap.put("m_wuyezhichu", total_tz_heji);
					i++;
				} //for循环结束
			}
			
			//取 “食材” 数据
			B_TZh q_shicai=new B_TZh(); //构造台账查询条件
			q_shicai.setTjxx_type_name("食材");
			q_shicai.setTz_xiangmu_name(b_TZh.getTz_xiangmu_name());
			q_shicai.setStart_time(start_time);
			q_shicai.setEnd_time(end_time);
			List<Map<String,Object>> rList3=b_TZhService.getTjxx(q_shicai); //取食材
			
			if(rList3.contains(null)){
				reMap.put("m_shicai", 0);
			}else{
				i=0;
				for(Map m:rList3){ //1条统计记录
					if(i==1){
						break;
					}
					System.out.println("取食材统计数据=="+m);
					double total_tz_heji=((BigDecimal)m.get("total_tz_heji")).doubleValue();
					reMap.put("m_shicai", total_tz_heji);
					i++;
				} //for循环结束
			}
			
			reMap.put("status", "success");
			reMap.put("message", "OK");
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			reMap.put("status", "error");
			reMap.put("message", e.getMessage());
		}
		return reMap;
	}
}
